package org.example.bean;


import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.example.util.ExceptionUtil;

import java.util.HashMap;
import java.util.List;
import java.util.Objects;


/**
 * @Desc: 关卡类，表示地图中的一个通行关卡，包含其位置信息及连接的疆域坐标。
 * @Author: yanghongjun
 * @Date: 2025/6/10
 **/
public class MapPass {
    private static final Logger logger = LogManager.getLogger(MapPass.class);

    /**
     * 关卡唯一标识ID
     */
    private long id;

    /**
     * 所属联盟id
     */
    private long allianceId;

    /**
     * 关卡初始坐标（中心点）
     */
    private Cord initCord;

    /**
     * 通行坐标映射表：记录该关卡连接的各个疆域及其对应的通行坐标节点
     * <疆域ID, 连接坐标节点>
     */
    private HashMap<Integer, Cord> cordHashMap = new HashMap<>();

    /**
     * 通向其他关卡的路径
     * <关卡id, 路径>
     */
    private HashMap<Long, List<JsonGamePos>> pathHashMap = new HashMap<>();

    /**
     * 默认构造函数
     */
    public MapPass() {
    }

    /**
     * 使用配置对象构造一个关卡实例
     *
     * @param passCfg 关卡配置数据
     */
    public MapPass(PassCfg passCfg) {
        String position = passCfg.Position;
        if (position == null || position.isEmpty()) {
            return;
        }
        String belongTer = passCfg.BelongTer;
        if (belongTer == null || belongTer.isEmpty()) {
            return;
        }
        // 解析关卡的位置坐标
        String[] split = position.split("_");
        if (split.length != 2) {
            logger.error("无效的关卡位置格式: {}", position);
            return;
        }
        try {
            int x = Float.valueOf(split[0]).intValue();
            int y = Float.valueOf(split[1]).intValue();
            this.initCord = new Cord(x, y);
        } catch (NumberFormatException e) {
            logger.error("关卡位置解析失败: {}, 错误: {}", position, ExceptionUtil.show(e));
            return;
        }
        // 解析关卡连接的疆域及对应坐标
        HashMap<Integer, Cord> map = new HashMap<>();
        for (String entry : belongTer.split(";")) {
            String[] parts = entry.split(":");
            if (parts.length != 2) {
                continue; // 格式错误跳过
            }
            try {
                int territoryId = Integer.parseInt(parts[0]);
                String[] coords = parts[1].split("_");
                if (coords.length != 2) {
                    continue; // 坐标格式错误
                }
                int x = Float.valueOf(coords[0]).intValue();
                int y = Float.valueOf(coords[1]).intValue();
                map.put(territoryId, new Cord(x, y));
            } catch (NumberFormatException e) {
                logger.error("疆域连接解析失败: {}, 错误: {}", entry, ExceptionUtil.show(e));
            }
        }
        this.setId(passCfg.ID);
        this.setCordHashMap(map);
    }

    /**
     * 获取关卡ID
     *
     * @return 关卡唯一ID
     */
    public long getId() {
        return id;
    }

    /**
     * 设置关卡ID
     *
     * @param id 新的ID值
     */
    public void setId(long id) {
        this.id = id;
    }

    /**
     * 获取关卡的初始坐标
     *
     * @return 初始坐标对象
     */
    public Cord getInitCord() {
        return initCord;
    }

    /**
     * 设置关卡的初始坐标
     *
     * @param initCord 新的初始坐标
     */
    public void setInitCord(Cord initCord) {
        this.initCord = initCord;
    }

    /**
     * 获取关卡连接的疆域与通行坐标的映射关系
     *
     * @return 疆域ID到坐标的映射表
     */
    public HashMap<Integer, Cord> getCordHashMap() {
        return cordHashMap;
    }

    /**
     * 设置关卡连接的疆域与通行坐标的映射关系
     *
     * @param cordHashMap 新的映射表
     */
    public void setCordHashMap(HashMap<Integer, Cord> cordHashMap) {
        this.cordHashMap = cordHashMap;
    }

    public HashMap<Long, List<JsonGamePos>> getPathHashMap() {
        return pathHashMap;
    }

    public void setPathHashMap(HashMap<Long, List<JsonGamePos>> pathHashMap) {
        this.pathHashMap = pathHashMap;
    }

    public long getAllianceId() {
        return allianceId;
    }

    public void setAllianceId(long allianceId) {
        this.allianceId = allianceId;
    }

    /**
     * 判断两个关卡是否相等（根据ID判断）
     *
     * @param o 被比较的对象
     * @return 是否相等
     */
    @Override
    public boolean equals(Object o) {
        if (this == o) {
            return true;
        }
        if (!(o instanceof MapPass)) {
            return false;
        }
        MapPass mapPass = (MapPass) o;
        return getId() == mapPass.getId();
    }

    /**
     * 返回关卡的哈希码（基于ID计算）
     *
     * @return 哈希码
     */
    @Override
    public int hashCode() {
        return Objects.hashCode(getId());
    }
}
